home *** CD-ROM | disk | FTP | other *** search
/ Software Vault: The Gold Collection / Software Vault - The Gold Collection (American Databankers) (1993).ISO / cdr10 / ehp10.zip / TASTE.C < prev    next >
C/C++ Source or Header  |  1993-06-19  |  26KB  |  651 lines
  1. /****************************************************************/
  2. /*                                                              */
  3. /*      MODUL:  taste.c                                         */
  4. /*                                                              */
  5. /*      FUNKTIONEN:                                             */
  6. /*              - lies_tasten (Tastenbelegunsfile einlesen)     */
  7. /*              - search_next (suche naechsten passenden Bef.)  */
  8. /*              - taste (Tastendruck auswerten)                 */
  9. /*              - newwgetch (Taste von Keyboard || Puffer lesen)*/
  10. /*              - exec_macro (Macro ausfuehren)                 */
  11. /*              - newgetstr (String mittels newgetch einlesen)  */
  12. /*              - get_comstr (Kommandostring einlesen)          */
  13. /*                                                              */
  14. /****************************************************************/
  15.  
  16. #ifdef OS2
  17. #include <os2.h>
  18. #else
  19. #define _ANSI_SOURCE
  20. #endif
  21.  
  22. #include "defs.h"
  23. #include "keys.h"
  24. #include <ctype.h>
  25.  
  26. extern char helpflag;
  27. extern int ks_index;
  28. extern short int *keystack,*e_keystack;  /* puffer-pointer */
  29. extern short int mc_index;
  30. extern WINDOW *status;
  31. extern char clear_buff, /* aus main.c */
  32.         *tasten_inf; /* Name des Tastenbelegungsfiles aus main.c */
  33. extern int do_macro(),do_control(),do_newline(),(*funktion[])();  /* funktionsarray aus auswertung.c f. get_comstr */
  34. extern puff_typ macro[];
  35. extern HMTX sem_handle;
  36.  
  37. /* *** globale Daten und Initialisierung *** */
  38. static short int eingabe[MAX_COMM_LEN]; /* Bisher eingelesene Zeichen          */
  39. static short int index=0,               /* Index in eingabe                    */
  40.          bef_index=0;           /* aktuelle moegliche Tastenkombination*/
  41. puff_typ  puff_feld[MACRO_NEST_DEPTH];  /* Macropuffer                         */
  42. comm_typ  *comm_feld;                   /* Tastenkombinationen                 */
  43. short int letter,                       /* Buchstabe, falls Befehl T_BUCHSTABE */
  44.       lastcode = -1,                /* Letzte Tastenkombination            */
  45.       newwgetch();
  46.  
  47. #ifndef OWN_CURSES
  48. /*****************************************************************************
  49. *
  50. *  Funktion       Warnton ausgeben (beep)
  51. *  --------
  52. *
  53. *  Beschreibung : Es wird ein CTRL-G ausgegeben, was einen Warnton erzeugt.
  54. *
  55. *****************************************************************************/
  56.  
  57. void beep()
  58. {
  59.    printf("");  /* Beep ausgeben */
  60. }
  61. #endif
  62.  
  63. /*****************************************************************************
  64. *
  65. *  Funktion       Tastenbelegungsfile einlesen (lies_tasten)
  66. *  --------
  67. *
  68. *  Beschreibung : Liest die Tastenbelegungsdatei in das Feld comm_feld ein.
  69. *
  70. *****************************************************************************/
  71.  
  72. void lies_tasten()
  73. {
  74.   /* *** interne Daten *** */
  75.   FILE               *f;     /* Filepointer fuer Tastenbelegungsdatei */
  76.   register short int i,      /* Zaehler fuer Kombinationsnummer       */
  77.              j;      /* Zaehler fuer Indexfeld                */
  78.   register int       n_info; /* Anzahl einzulesender Strings          */
  79.   short int          *index; /* Feld fuer Stringindices               */
  80.   char               *hilf,  /* Zeiger auf Hilfstring                 */
  81.              dummy [256]; /* Zum einlesen der Hilfstring      */
  82.  
  83.   if (!(f = fopen (tasten_inf,"rb"))) /* Tastebelegungsdatei oeffnen */
  84.   {
  85.     print_stat(PROMPT_KEYREAD);
  86.     wart_ret();
  87.     ende(1, TRUE);
  88.   }
  89.   if(fread(&mc_index,sizeof(short int),1,f) < 1) /* Anzahl Kommandos lesen */
  90.   {
  91.     print_stat(PROMPT_KEYLENGTH);
  92.     wart_ret();
  93.     ende(1, TRUE);
  94.   }
  95.   comm_feld = (comm_typ*)  reserve_mem((mc_index+1) * sizeof(comm_typ));
  96.   index     = (short int*) reserve_mem((mc_index+1) * sizeof(short int));
  97.   for (n_info=i=0;i<=mc_index;i++)  /* Alle Kombinationen einlesen */
  98.     if (fread (&comm_feld[i].blen,sizeof(short int),1,f) < 1)
  99.     { /* Laenge der Kombination einlesen hat nicht geklappt */
  100.       print_stat(PROMPT_KEYCOMM);
  101.       wart_ret();
  102.       ende(1, TRUE);
  103.     }
  104.     else /* Laenge Einlesen hat geklappt, dann eigentliche Kombination lesen */
  105.     {
  106.       if (comm_feld[i].blen > MAX_COMM_LEN)
  107.       { /* Befehl seltsamerweise zu lang */
  108.     print_stat(PROMPT_KEYCOMLEN);
  109.     wart_ret();
  110.     ende(1, TRUE);
  111.       }
  112.       fread (comm_feld[i].befehl,sizeof(short int),comm_feld[i].blen,f);
  113.       fread (&index[i],sizeof(short int),1,f); /* Stringindex lesen */
  114.       comm_feld[i].info_text = NULL;
  115.       if(index[i] > -1)
  116.     for (n_info++,j=0;j<i;j++)  /* Testen, ob Stringindex schon in */
  117.       if (index[j] == index[i]) /* Indextabelle enthalten ist      */
  118.       {
  119.         n_info--;   /* Nur einen weiteren String einlesen,  */
  120.         break;      /* falls neuer Index                    */
  121.       }
  122.     }
  123.  
  124.   /* Jetzt die noetige Anzahl Hilfstrings einlesen */
  125.   for (i=0;i<n_info;i++)
  126.   {
  127.     /* Einen String einlesen und testen, ob er mit '\n' terminiert ist */
  128.     if (!fgets (dummy,255,f) || !(hilf = strchr(dummy,'\n')))
  129.     {
  130.       print_stat(PROMPT_KEYHELP);
  131.       wart_ret();
  132.       ende(1, TRUE);
  133.     }
  134.     *hilf = '\0';  /* '\n' ueberschreiben */
  135.     if (!(hilf = save_text (dummy))) /* Hilfstext im Speicher ablegen */
  136.     {
  137.       print_stat(PROMPT_KEYHELPEM);
  138.       wart_ret();
  139.       ende(1, TRUE);
  140.     }
  141.     for (j=0;j<=mc_index;j++) /* Bei allen Tastenkombinationen, die den */
  142.       if (index[j] == i) /* aktuellen Stringindex aufweisen, Zeiger auf */
  143.     comm_feld[j].info_text = hilf; /* Hilfstext setzen              */
  144.   }
  145.   fclose (f);
  146. }
  147.  
  148. /*****************************************************************************
  149. *
  150. *  Funktion       suche naechsten passenden Befehl (search_next)
  151. *  --------
  152. *
  153. *  Parameter    : eingabe   :
  154. *                   Typ          : short int[]
  155. *                   Wertebereich : Pointer auf integer
  156. *                   Bedeutung    : bisher eingelesene Tastencodes
  157. *
  158. *               : index     :
  159. *                   Typ          : short int
  160. *                   Wertebereich : 0..MAX_COMM_LEN
  161. *                   Bedeutung    : index des zuletzt eingelesenen Zeichens
  162. *
  163. *               : bef_index :
  164. *                   Typ          : short int
  165. *                   Wertebereich : 0..mc_index
  166. *                   Bedeutung    : aktuelle, nicht mehr passende Tasten-
  167. *                                  kombination
  168. *
  169. *  Ergebnis     :
  170. *                   Typ          : short int
  171. *                   Wertebereich : -1,1..mc_index
  172. *                   Bedeutung    : naechste passende Tastenkombination
  173. *
  174. *  Beschreibung : Sucht in comm_feld die naechste auf die bisher eingele-
  175. *                 lesenen Zeichen passende Tastenkombination. Wird keine
  176. *                 entsprechende Kombination gefunden, so wird -1 zurueck-
  177. *                 gegeben.
  178. *
  179. *****************************************************************************/
  180.  
  181. short int search_next(eingabe,index,bef_index)
  182. short int eingabe[];
  183. register short int index,bef_index;
  184. {
  185.   /* *** interne Daten *** */
  186.   register short int *inp, /* Zeiger in alte Eingabe            */
  187.              *bef; /* Zeiger in moeglichen "Kandidaten" */
  188.  
  189.   while(++bef_index <= mc_index) /* Alle weiteren Kombinationen testen */
  190.   {
  191.     for(inp = eingabe,bef = comm_feld[bef_index].befehl;
  192.     (inp <=eingabe+index) && *inp == *bef;inp++,bef++);
  193.     if(inp > eingabe + index) /* passende gefunden */
  194.       return(bef_index);
  195.   }
  196.   return(-1);
  197. }
  198.  
  199. /*****************************************************************************
  200. *
  201. *  Funktion       Tastendruck auswerten (taste)
  202. *  --------
  203. *
  204. *  Parameter    :   w
  205. *                   Typ          : WINDOW *
  206. *                   Wertebereich : Pointer auf curses-Windowstruktur
  207. *                   Bedeutung    : Fenster, in dem Befehl eingelesen werden
  208. *                                  soll
  209. *
  210. *  Ergebnis     :
  211. *                   Typ          : short int
  212. *                   Wertebereich : 0..mc_index+1
  213. *                   Bedeutung    : Interne Nummer der Tastenkombination
  214. *
  215. *  Beschreibung : Es wird eine Taste eingelesen und in der Tabelle nach
  216. *                 einer Kombination beginnend mit dieser Taste gesucht.
  217. *                 Wird keine gefunden, so wird mc_index+1 zurueckgegeben und
  218. *                 die Taste in letter gespeichert.
  219. *                 Wird die Kombination mit dieser Taste abgeschlossen, so
  220. *                 wird die Nummer der gefundenen Kombination zurueckgegeben.
  221. *                 Sonst wird das naechste Zeichen gelesen. Ergibt sich da-
  222. *                 durch keine zulaessige Kombination, so werden alle Zeichen
  223. *                 verworfen. Sonst wird wieder verglichen usw.
  224. *                 Ist das Eingabefenster das Statusfenster, so wird der
  225. *                 Cursor nach Anzeige eines Infotextes nicht positioniert.
  226. *
  227. *****************************************************************************/
  228.  
  229. short int taste(w)
  230. WINDOW *w;
  231. {
  232.   /* *** interne Daten und Initialisierung *** */
  233.   short int hilf;        /* Zwischenspeicher fuer letzte Tastenkombination */
  234.   char      hgz = FALSE  /* Flag, ob ein Hilfstext angezeigt wurde         */
  235. #ifdef MOUSE
  236.         , mouse_akt=FALSE  /* Flag, ob Maus aktiviert ist */
  237. #endif
  238.                 ;
  239.  
  240.   if (lastcode != -1)
  241.   {
  242.     hilf = lastcode; /* Falls eine Funktion ein "ungetchar" ausgefuehrt hat, */
  243.     lastcode = -1;   /* wird der geungetcharte code zurueckgegeben.          */
  244.     return (hilf);
  245.   }
  246.   index = bef_index = 0; /* Alle Kombinationen kommen in Frage */
  247.   while(1)
  248.   {
  249. #ifdef MOUSE
  250.     if(!mouse_akt && ks_index == -1 && !index) /* Falls kein Macro aktiv ist: */
  251.     { /* und noch kein Zeichen eingelesen wurde */
  252. #ifdef OS2
  253.       DosReleaseMutexSem (sem_handle);
  254. #else
  255.       set_mouse_int(MOUSE_MASK);  /* Vor Eingabe Maus aktivieren */
  256. #endif
  257.       mouse_akt = TRUE;
  258.       hide_show (MOUSE_SHOW);
  259.     }
  260. #endif
  261.     letter = eingabe[index] = newwgetch(w); /* Ein Zeichen von Tastatur/Macro */
  262. #ifdef MOUSE
  263.     if(mouse_akt)
  264.     { /* Nach erstem gelesenen Zeichen Maus deaktivieren */
  265.       mouse_akt = FALSE; /* damit Maus nicht zwischen ein Kommando funkt */
  266.       hide_show (MOUSE_HIDE);
  267. #ifdef OS2
  268.       DosRequestMutexSem (sem_handle,-1);
  269. #else
  270.       set_mouse_int(0); 
  271. #endif /* OS2 */
  272.     }
  273. #endif /* MOUSE */
  274.     if(hgz)  /* wurde Hilfstext angezeigt? */
  275.     {
  276.       hgz = FALSE;
  277.       clear_stat();                   /* Hilfstext wieder loeschen              */
  278.       if(w != status)                 /* wenn nicht im Statusfenster eingelesen */
  279.     pos_cursor();                 /* wurde, dann muss Cursor wieder positio-*/
  280.     }                                 /* niert werden */
  281.     if (letter == -1)                 /* War nodelay gesetzt und keine Taste    */
  282.       if(!index)                      /* gedrueckt ? Falls erstes Zeichen */
  283.     return (-1);                  /* eine Kombination, dann -1 zurück */
  284.       else                            /* Sonst -1 ignorieren, da sonst evtl. */
  285.     continue;                     /* Kombination "zerhackt" würde */
  286.     if(comm_feld[bef_index].befehl[index] != eingabe[index])
  287.     {
  288.       /* naechsten passenden Befehl suchen */
  289.       if((bef_index = search_next(eingabe,index,bef_index)) < 0) /* keinen gefunden? */
  290.     if(!index && (letter % 256))    /* normal char and not zero */
  291.     {
  292.       index++;                      /* ein zeichen eingelesen */
  293.       return(bef_index = mc_index+1);
  294.     }
  295.     else                            /* Befehl verwerfen */
  296.     {
  297.       index = bef_index = 0;
  298.       continue;
  299.     }
  300.     }
  301.     if(++index == comm_feld[bef_index].blen) /* passte Zeichen, dann testen, */
  302.       return(bef_index);                /* ob komplette Kombination gelesen. */
  303.     if (helpflag && comm_feld[bef_index].info_text)
  304.     { /* wenn Hilfstexte angezeigt werden sollen und die momentane Kom- */
  305.       hgz = TRUE; /* bination einen hat, dann ausgeben */
  306.       print_hilf (comm_feld[bef_index].info_text);
  307.     }
  308.   }
  309. }
  310.  
  311. /*****************************************************************************
  312. *
  313. *  Funktion       Zeichen aus Puffer oder v. Tastatur lesen (newwgetch)
  314. *  --------
  315. *
  316. *  Parameter    : w         :
  317. *                   Typ          : WINDOW *
  318. *                   Wertebereich : Pointer auf curses-Windowstruktur
  319. *                   Bedeutung    : Fenster, in dem eingegeben werden soll
  320. *
  321. *  Ergebnis     :
  322. *                   Typ          : short int
  323. *                   Wertebereich : curses-Tastenwerte
  324. *                   Bedeutung    : aktuelles Zeichen (s.u.)
  325. *
  326. *  Beschreibung : Diese Funktion liefert das naechste aktuelle Zeichen
  327. *                 zurueck. Dies ist, falls noch Zeichen im Puffer sind, d.h.
  328. *                 ks_index noch nicht -1 ist bzw. in Puffer 0 noch nicht das
  329. *                 letzte Zeichen verarbeitet wurde, das aktuelle Zeichen im
  330. *                 Puffer, andernfalls eine eingelesene Taste.
  331. *                 Zur Erklaerung der Puffer:
  332. *                   ks_index ist der Index des aktuellen Puffers. Ist der
  333. *                   Puffer [ks_index] leer und ks_index>0, so wird in
  334. *                   Puffer [ks_index-1] weitergelesen.
  335. *                   Die Puffer sind in einer Tabelle vom Typ puff_typ[]
  336. *                   gespeichert. Das Strukturelement begin stellt einen
  337. *                   Zeiger auf das aktuelle Element dar, waehrend end auf
  338. *                   das Pufferende zeigt.
  339. *                   keystack ist ein Pointer in den aktuellen Puffer und
  340. *                   zeigt auf das aktuelle Element (falls ks_index>=0);
  341. *                   e_keystack zeigt auf das Ende des aktuellen Puffers.
  342. *
  343. *****************************************************************************/
  344.  
  345. short int newwgetch(w)
  346. WINDOW *w;
  347. {
  348.   if(clear_buff) /* Wenn Puffer als zu loeschend markiert sind: */
  349.   {
  350.     while(ks_index > -1)  /* Macro beenden, evtl. freizugebende Strings freigeben */
  351.     {
  352.       if(puff_feld[ks_index].free_flag)
  353.     line_free(puff_feld[ks_index].begin);
  354.       ks_index--;
  355.     }
  356.     clear_buff = FALSE;  /* Flag zuruecksetzen */
  357.   }
  358.   while(ks_index != -1)  /* Wenn ein Puffer aktiv, dann aus Puffer lesen */
  359.   {
  360.     if(keystack && keystack <= e_keystack)    /* noch Zeichen im Puffer? */
  361.       return(*keystack++); /* Dann  aktuelles Pufferzeichen zurueckgeben */
  362.     else       /* Puffer leer */
  363.       if(puff_feld[ks_index].anz_rep) /* War es eine Repeat-Funktion ? */
  364.       {
  365.     puff_feld[ks_index].anz_rep--;
  366.     keystack = puff_feld[ks_index].begin; /* Selben Puffer nochmal */
  367.     e_keystack = puff_feld[ks_index].end;
  368.       }
  369.       else /* Puffer war kein Repeat-Puffer, Puffer loeschen */
  370.       {
  371.     if(puff_feld[ks_index].free_flag)   /* falls free_flag gesetzt ist, Puffer freigeben */
  372.       line_free(puff_feld[ks_index].begin);
  373.     /* keine Zeichen mehr im aktuellen Puffer; vielleicht noch im vorigen? */
  374.     if(--ks_index >= 0)     /* noch nicht erster Puffer? */
  375.     {
  376.       keystack = puff_feld[ks_index].current; /* im vorherigen Puffer weiter */
  377.       e_keystack = puff_feld[ks_index].end;
  378.     }
  379.       }
  380.   }
  381.   /* Kein Puffer (mehr) aktiv, von Tastatur lesen */
  382.   return(wgetch(w));
  383. }
  384.  
  385.  
  386. /*****************************************************************************
  387. *
  388. *  Funktion       Macro ausfuehren (exec_macro)
  389. *  --------
  390. *
  391. *  Parameter    : mnum      :
  392. *                   Typ          : short int
  393. *                   Wertebereich : 'a' - 'a'+ANZ_MACROS
  394. *                   Bedeutung    : Name des auszufuehrenden Macros
  395. *
  396. *  Beschreibung : Der gewuenschte Macro wird ausgefuehrt, indem auf den
  397. *                 Pufferstapel ein neuer Puffer geschoben wird, in den der
  398. *                 Macrotext kopiert wird. Falls das nicht der erste Puffer
  399. *                 auf dem Stapel ist, wird die Position im alten Puffer
  400. *                 in current abgelegt. Anschliessend wird keystack und
  401. *                 ekeystack korrekt gesetzt.
  402. *
  403. *****************************************************************************/
  404.  
  405. void exec_macro(mnum)
  406. register short int mnum;
  407. {
  408.   /* *** interne Daten *** */
  409.   char dummy[80], /* Zum Zusammenflicken der Fehlermeldung */
  410.        old_delay; /* Zwischenspeicher fuer nodelay-Zustand */
  411.  
  412.   if(mnum>='a' && mnum<='z')  /* exec macro */
  413.     if(macro[mnum-='a'].begin) /* Macro auch nicht leer ? */
  414.       if(ks_index < MACRO_NEST_DEPTH - 1) /* Verschachtelungstiefe OK ? */
  415.       {
  416.     if(ks_index >=0) /* falls schon ein Puffer aktiv, aktuelle Position */
  417.       puff_feld[ks_index].current = keystack;       /* im Puffer merken */
  418.  
  419.     /* Zeiger in neuen Puffer setzen */
  420.     keystack = puff_feld[++ks_index].begin = macro[mnum].begin;
  421.     e_keystack = puff_feld[ks_index].end = macro[mnum].end;
  422.     puff_feld[ks_index].anz_rep = 0; /* Puffer ist nicht zu wiederholen */
  423.     puff_feld[ks_index].free_flag = FALSE;  /* Puffer nach Ausfuehrung  */
  424.       } /* nicht freigeben, da sonst Macrotext freigegeben wuerde */
  425.       else /* zu grosse Verschachtelungstiefe */
  426.       {
  427.     clear_buff = TRUE;  /* beim naechsten Aufruf von newwgetch() Puffer loeschen */
  428. #ifdef OWN_CURSES
  429.     if(old_delay = akt_winp->winp->_dlyflag)
  430.       nodelay(akt_winp->winp,FALSE);  /* falls true eingestellt */
  431. #endif
  432.     print_stat(PROMPT_RECURSION);
  433.     wart_ret();
  434.     clear_stat();
  435. #ifdef OWN_CURSES
  436.     nodelay(akt_winp->winp,old_delay);
  437. #endif
  438.       }
  439.     else /* Macro war leer */
  440.     {
  441.       sprintf(dummy,PROMPT_MACROEMPT,mnum+'a');
  442.       print_err(dummy);
  443.     }
  444. }
  445.  
  446. /*****************************************************************************
  447. *
  448. *  Funktion       String von Tastatur einlesen (newgetstr)
  449. *  --------
  450. *
  451. *  Parameter    : w         :
  452. *                   Typ          : WINDOW *
  453. *                   Wertebereich : Pointer auf curses-Windowstruktur
  454. *                   Bedeutung    : Fenster, in dem Text eingelesen werden soll
  455. *
  456. *                 y         :
  457. *                   Typ          : int
  458. *                   Wertebereich : 0 - Anzahl der Zeilen im Window-1
  459. *                   Bedeutung    : Zeile, in der eingelesen werden soll
  460. *
  461. *                 x         :
  462. *                   Typ          : int
  463. *                   Wertebereich : 0 - Anzahl der Spalten im Window-1
  464. *                   Bedeutung    : Spalte, ab der eingelesen werden soll
  465. *
  466. *                 buff      :
  467. *                   Typ          : char *
  468. *                   Wertebereich : Pointer auf Speicherbereich
  469. *                   Bedeutung    : Speicherbereich, in den Eingabe ge-
  470. *                                  schrieben wird (muss min. max_anz + 1
  471. *                                  Bytes lang sein)
  472. *
  473. *                 max_anz   :
  474. *                   Typ          : int
  475. *                   Wertebereich : 0 - MAX_INT
  476. *                   Bedeutung    : Anzahl maximal einzulesender Zeichen
  477. *                                  = 0 : wartet nur auf RETURN
  478. *                 typ       :
  479. *                   Typ          : int
  480. *                   Wertebereich : GS_NUM, GS_ANY
  481. *                   Bedeutung    : GS_NUM: nur Ziffern einlesen
  482. *                                  GS_ANY: alle Zeichen zulassen
  483. *
  484. *  Beschreibung : Diese Funktion liest mittels newgetch einen String ein.
  485. *                 Hierbei sind die Funktionstasten Backspace (loesche Zeichen
  486. *                 links und bewege Cursor um eine Spalte nach links), Pfeil
  487. *                 links (Cursor um eine Position nach links) und Pfeil rechts
  488. *                 (Cursor um eine Position nach rechts) erlaubt. Maximal
  489. *                 koennen max_anz Zeichen eingegeben werden; versucht man,
  490. *                 mehr Zeichen einzugeben, ertoent ein Piepston und die Ein-
  491. *                 gabe wird ignoriert.
  492. *                 Da bei Backspace die Zeile bis zum Ende geloescht wird,
  493. *                 kann unbeabsichtigt Information geloescht werden (s.u.).
  494. *
  495. *****************************************************************************/
  496.  
  497. void newgetstr(w,y,x,buff,max_anz,typ)
  498. WINDOW *w;
  499. int y,x,max_anz,typ;
  500. char *buff;
  501. {
  502.   /* *** interne Daten und Initialisierung *** */
  503.   short int tmp_inp;        /* Zum einlesen eines Zeichens          */
  504.   int       akt_index = 0,  /* Index in Eingabepuffer               */
  505.         max_index = -1; /* Index fuer letztes Zeichen in Puffer */
  506.  
  507.   if(max_anz < 0)
  508.     return;
  509.  
  510.   buff[akt_index] = '\0';  /* Pufferende markieren */
  511.   do
  512.   {
  513.     wmove(w,y,x + akt_index); /* Cursor an gewuenschte Position */
  514.     wrefresh(w);
  515.     switch(tmp_inp = newwgetch(w))    /* echoing has to be disabled */
  516.     {
  517.       case '\010':          /* Backspace */
  518.     if(akt_index > 0)
  519.     { /* Pufferrest eins nach links kopieren */
  520.       fwdcpy(&buff[akt_index-1],&buff[akt_index]);
  521.       akt_index--;
  522.       max_index--;
  523.       mvwaddstr(w,y,x,buff);
  524.       wclrtoeol(w); /* bis Zeilenende loeschen wg. evtl. ESC-codes */
  525.     }
  526.       break;
  527. #ifndef OS2 /* Bei OS/2 ist alles in einem Zeichen enthalten */
  528.       case '\0':            /* "Escape"-Sequenz */
  529.     switch(newwgetch(w))
  530.     {
  531. #endif
  532.       case KEY_LEFT:        /* Pfeil links */
  533.         if(akt_index > 0)
  534.         akt_index--;
  535.         break;
  536.       case KEY_DC:          /* Delete char */
  537.         if(akt_index <= max_index)
  538.         {
  539.           fwdcpy(&buff[akt_index],&buff[akt_index+1]);
  540.           max_index--;
  541.           mvwaddstr(w,y,x,buff);
  542.           wclrtoeol(w); /* bis Zeilenende loeschen wg. evtl. ESC-codes */
  543.         }
  544.         break;
  545.       case KEY_RIGHT:       /* Pfeil rechts */
  546.         if(akt_index <= max_index)
  547.         akt_index++;
  548.         break;
  549. #ifndef OS2
  550.       default:
  551.         beep();  /* Unbekannte "Escape"-Sequenz */
  552.     }
  553.     break;
  554. #endif
  555.       default:
  556.     /* Bei allen anderen Zeichen ausser dem abschliessenden Zeichen   */
  557.     /* Typ testen und falls korrekt und noch Platz im Puffer, Zeichen */
  558.     /* eintragen */
  559.     if(tmp_inp != END_KEY)
  560.       if(max_index < max_anz-1
  561.       && (typ & GS_NUM && isdigit(tmp_inp) || typ & GS_ANY))
  562.       {
  563.         max_index++;
  564.         revcpy(&buff[akt_index+1],&buff[akt_index]);  /* insert char */
  565.         buff[akt_index++] = tmp_inp;
  566.         mvwaddstr(w,y,x,buff);
  567.       }
  568.       else      /* Typ falsch oder Puffer voll */
  569.         beep();
  570.       break;
  571.     }
  572.   } while(tmp_inp != END_KEY);
  573. }
  574.  
  575. /*****************************************************************************
  576. *
  577. *  Funktion       Kommando-String einlesen (get_comstr)
  578. *  --------
  579. *
  580. *  Parameter    : anf       :
  581. *                   Typ          : short int **
  582. *                   Wertebereich : Pointer auf Pointer auf short int
  583. *                   Bedeutung    : Anfang des Kommandostrings
  584. *
  585. *                 end       :
  586. *                   Typ          : short int **
  587. *                   Wertebereich : Pointer auf Pointer auf short int
  588. *                   Bedeutung    : Ende des Kommandostrings
  589. *
  590. *
  591. *  Beschreibung: Es wird ein Kommandostring eingelesen, der mit RETURN ter-
  592. *                miniert sein muss. Die maximale Laenge ist hierbei durch
  593. *                MAX_MACRO_LEN vorgegeben. Anschliessend wird der eingele-
  594. *                sene String mittels reallocmem und memcpy gesichert und
  595. *                in *anf und *end Anfang bzw. Ende des Strings eingetragen.
  596. *                Moechte man in den Kommandostring ein RETURN einfuegen, so
  597. *                kann man dies mittels der Kombination CTRL-c RETURN, ein
  598. *                CTRL-c laesst sicht durch CTRL-c CTRL-c einfuegen.
  599. *                Hat der Eingabestring (ohne RETURN) die Laenge 0, so wird
  600. *                ein NULL-Pointer zurueckgeliefert.
  601. *
  602. ***************************************************************************/
  603.  
  604. void get_comstr(anf,end)
  605. short int **anf,**end;
  606. {
  607.   /* *** interne Daten und Initialisierung *** */
  608.   register short int bef, /* Zum Einlesen einer Tastenkombination     */
  609.              h;   /* Zum Einlesen des Macrozeichens           */
  610.   short int          mbuff[MAX_MACRO_LEN+1];     /* Eingabepuffer     */
  611.   register int       i=0, /* Index in Eingabepuffer mbuff             */
  612.              i2;  /* Zwischenspeicher fuer Index bzgl. Macros */
  613.  
  614.   print_stat(PROMPT_COMMAND);
  615.   while(funktion[bef = taste(status)] != do_newline) /* code fuer newline ist ende */
  616.   {
  617.     if(i + index > MAX_MACRO_LEN) /* Noch Platz ? */
  618.     {
  619.       clear_stat();
  620.       beep();
  621.       pe_or(PROMPT_KEYLONG);
  622.     }
  623.     else                          /* Es war noch Platz */
  624.       if(funktion[bef] == do_control) /* controlcode einfuegen? */
  625.     mbuff[i++] = newwgetch(status); /* dann ein Zeichen lesen und rein */
  626.       else
  627.     if(funktion[bef] == do_macro && i+index+1 < MAX_MACRO_LEN)  /* Macro-Befehl? */
  628.     { /* zuerst Befehl sichern */
  629.       memcpy(&mbuff[i],eingabe,index * sizeof(short int));
  630.       i += index;
  631.       mbuff[i++] = newwgetch(status); /* Macrozeichen lesen und einfuegen */
  632.     }
  633.     else  /* Kein Macrobefehl */
  634.     {     /* Befehlskombination (eingabe) in Puffer kopieren */
  635.       memcpy(&mbuff[i],eingabe,index * sizeof(short int));
  636.       i += index;
  637.     }
  638.     clear_stat();
  639.     print_stat(PROMPT_COMMAND);
  640.   }
  641.   clear_stat();
  642.   if(!i)  /* Eingabelaenge NULL?*/
  643.     *anf = *end = NULL;
  644.   else
  645.   {
  646.     *anf = (short int *)reserve_mem(i * sizeof(short int));
  647.     *end = &(*anf)[i-1];  /* Zeiger auf Anfang und Ende setzen */
  648.     memcpy(*anf,mbuff,i * sizeof(short int)); /* Kommandostring kopieren */
  649.   }
  650. }
  651.